package config

import (
	"fmt"
	"gopkg.in/yaml.v3"
	"os"
)

// Config 总配置结构体
type Config struct {
	Redis RedisConfig `yaml:"redis"`
	MinIO MinIOConfig `yaml:"minio"`
	OSS   OSSConfig   `yaml:"oss"`
	App   AppConfig   `yaml:"app"`
}

// RedisConfig Redis 配置
type RedisConfig struct {
	Host         string `yaml:"host"`
	Port         int    `yaml:"port"`
	DB           int    `yaml:"db"`
	Password     string `yaml:"password"`
	PoolSize     int    `yaml:"pool_size"`
	MinIdleConns int    `yaml:"min_idle_conns"`
}

// MinIOConfig MinIO 配置
type MinIOConfig struct {
	Endpoint  string `yaml:"endpoint"`
	AccessKey string `yaml:"access_key"`
	SecretKey string `yaml:"secret_key"`
	Secure    bool   `yaml:"secure"`
	Region    string `yaml:"region"`
}

// OSSConfig OSS 配置
type OSSConfig struct {
	Domain string `yaml:"domain"`
}

// AppConfig 应用配置
type AppConfig struct {
	Spider SpiderConfig `yaml:"spider"`
	Image  ImageConfig  `yaml:"image"`
}

// SpiderConfig 采集配置
type SpiderConfig struct {
	SleepMin       int    `yaml:"sleep_min"`
	SleepAll       int    `yaml:"sleep_all"`
	ArticleTimeout int    `yaml:"article_timeout"`
	MaxRetries     int    `yaml:"max_retries"`
	UserAgent      string `yaml:"user_agent"`
}

// ImageConfig 图片配置
type ImageConfig struct {
	DefaultDir   string   `yaml:"default_dir"`
	MaxSize      int64    `yaml:"max_size"`
	AllowedTypes []string `yaml:"allowed_types"`
}

// LoadConfig 加载配置文件
func LoadConfig(configPath string) (*Config, error) {
	// 如果未指定配置文件路径，使用默认路径
	if configPath == "" {
		configPath = "config/config.yaml"
	}

	// 检查配置文件是否存在
	if _, err := os.Stat(configPath); os.IsNotExist(err) {
		return nil, fmt.Errorf("配置文件不存在: %s", configPath)
	}

	// 读取配置文件
	data, err := os.ReadFile(configPath)
	if err != nil {
		return nil, fmt.Errorf("读取配置文件失败: %v", err)
	}

	// 解析 YAML
	var config Config
	if err := yaml.Unmarshal(data, &config); err != nil {
		return nil, fmt.Errorf("解析配置文件失败: %v", err)
	}

	// 验证配置
	if err := config.Validate(); err != nil {
		return nil, fmt.Errorf("配置验证失败: %v", err)
	}

	return &config, nil
}

// Validate 验证配置
func (c *Config) Validate() error {
	// 验证 Redis 配置
	if c.Redis.Host == "" {
		return fmt.Errorf("Redis host 不能为空")
	}
	if c.Redis.Port <= 0 || c.Redis.Port > 65535 {
		return fmt.Errorf("Redis port 必须在 1-65535 之间")
	}
	// 验证 MinIO 配置
	if c.MinIO.Endpoint == "" {
		return fmt.Errorf("MinIO endpoint 不能为空")
	}
	if c.MinIO.AccessKey == "" {
		return fmt.Errorf("MinIO access_key 不能为空")
	}
	if c.MinIO.SecretKey == "" {
		return fmt.Errorf("MinIO secret_key 不能为空")
	}

	// 验证 OSS 配置
	if c.OSS.Domain == "" {
		return fmt.Errorf("OSS domain 不能为空")
	}

	// 验证应用配置
	if c.App.Spider.SleepMin <= 0 {
		return fmt.Errorf("sleep_min 必须大于 0")
	}
	if c.App.Spider.SleepAll <= 0 {
		return fmt.Errorf("sleep_all 必须大于 0")
	}
	if c.App.Spider.ArticleTimeout <= 0 {
		return fmt.Errorf("article_timeout 必须大于 0")
	}

	return nil
}

// GetRedisAddr 获取 Redis 连接地址
func (c *RedisConfig) GetRedisAddr() string {
	return fmt.Sprintf("%s:%d", c.Host, c.Port)
}

var GlobalConfig *Config

func init() {
	loadConfig, err := LoadConfig("config/config.yaml")
	if err != nil {
		panic(err)
	}
	GlobalConfig = loadConfig
}
